import { get } from '@renderer/utils/api'
import { useMd5 } from '@renderer/hooks/md5'
const md5Hook = useMd5()

export function useCommonTools() {
    // 获取文件的扩展名   isSuffix: true 包含文件后缀 反之， 不包含
    const getFileExtensionFromUrl = (url: string, isSuffix = false) => {
        let regex = isSuffix ? /\/([^\/]+)$/ : /\.[0-9a-z]+$/i;
        const match = url.match(regex)

        if (match?.length) {
            return isSuffix ? match[1] : match[0].substring(1);
        }

        return ''
    }

    // 数组长度进度值
    const calculateProgress = (array, maxLength = 100) => {
        console.log('maxLength', maxLength)
        if (maxLength === 0) {
            return 0; // 防止除以0的情况
        }
        if (array + 1 === maxLength) {
            return 100;
        } else {
            const progress = (array / maxLength) * 100;
            return parseInt(String(progress)); // 确保进度不超过100%
        }
    }

    // 字符串转化为hexArray
    const stringToHexArray = (str: string) => {
        let hexArray: number[] = [];
        for (let i = 0; i < str.length; i++) {
            let hex = str.charCodeAt(i);
            // 确保每个十六进制值都是两位数，如果是单个数字则前面补0
            hexArray.push(hex);
        }
        return hexArray;
    }

    // 将Uint8Array转换为十六进制字符串
    const Bytes2HexString = (arrBytes) => {
        let str = "";
        for (let i = 0; i < arrBytes.length; i++) {
            let tmp;
            const num = arrBytes[i];
            if (num < 0) {
                //此处填坑，当byte因为符合位导致数值为负时候，需要对数据进行处理
                tmp = (255 + num + 1).toString(16);
            } else {
                tmp = num.toString(16);
            }
            if (tmp.length === 1) {
                tmp = "0" + tmp;
            }
            str += tmp;
        }
        return str;
    }

    //16进展字符串转16进制数组
    const hexStringToHexArray = (hexString) => {
        // 移除可能的'0x'前缀
        hexString = hexString.replace(/^0x/, '');

        // 存储十六进制值的数组
        const hexArray: number[] = [];

        // 遍历字符串，每次处理两个字符
        for (let i = 0; i < hexString.length; i += 2) {
            // 获取每两个字符，如果字符串长度为奇数，则最后一组可能只有一个字符
            const hexPair = hexString.slice(i, i + 2);
            // 将十六进制字符对转换为数值，并推入数组
            hexArray.push(parseInt(hexPair, 16));
        }

        return hexArray;
    }

    const hexToByte = (hex) => {
        // 将十六进制字符串转换为十进制整数
        let decimal = parseInt(hex, 16);
        // 确保结果是一个字节（0-255）
        return decimal & 0xFF;
    }

    // hexArray to string
    const hexArrayToString = (hexArray) => {
        const uint8Array = new Uint8Array(hexArray);
        const result = new TextDecoder("utf-8").decode(uint8Array);
        return result
    }

    // 获取版本
    const getVersionVal = (version) => {
        const regex = /V(\d+\.\d+(\.\d+)?)/i;
        const match = version.match(regex)

        if (match) {
            return match[1]
        }
    }

    // 比较版本号是否最新
    const compareAndUpgrade = (versionCurrent, versionLatest) => {
        // 将版本号拆分成数组
        const currentParts = versionCurrent?.split('.').map(Number);
        const latestParts = versionLatest?.split('.').map(Number);

        // 比较版本号的每个部分
        for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
            // 如果当前版本的当前部分不存在，则认为是0
            const currentPart = i < currentParts.length ? currentParts[i] : 0;
            // 如果最新版本的当前部分不存在，则认为是0
            const latestPart = i < latestParts.length ? latestParts[i] : 0;

            // 如果当前版本的当前部分小于最新版本的，则需要升级
            if (currentPart < latestPart) {
                return true;
            }
            // 如果当前版本的当前部分大于最新版本的，则不需要升级
            if (currentPart > latestPart) {
                return false
            }
        }

        // 如果所有部分都相等，则两个版本号相同，不需要升级
        return false
    }

    // 签名
    const generateSignature = (url: string, t: number, key: string) => {
        // 构建签名字符串
        const signStr = `url=${url}||t=${t}||key=${key}`
        // 使用 MD5 加密
        const md5Hash = md5Hook.hashStr(signStr).toUpperCase()
        const signature = md5Hook.hashStr(md5Hash.substring(8, 16)).toUpperCase()

        return signature
    }

    const toByteArray = (value, low2High = true) => {
        const byteArray = new Uint8Array(4);

        if (low2High) {
            byteArray[0] = value & 0xFF;
            byteArray[1] = (value >> 8) & 0xFF;
            byteArray[2] = (value >> 16) & 0xFF;
            byteArray[3] = (value >> 24) & 0xFF;
        } else {
            byteArray[0] = (value >> 24) & 0xFF;
            byteArray[1] = (value >> 16) & 0xFF;
            byteArray[2] = (value >> 8) & 0xFF;
            byteArray[3] = value & 0xFF;
        }

        return byteArray
    }

    const combineBytesToDecimal = (highByte, lowByte) => {
        return (highByte << 8) | lowByte;
    }

    // 字典
    const getDicts = (dictType) => {
        return get(`/common/type/${dictType}`)
    }

    return {
        getFileExtensionFromUrl,
        calculateProgress,
        stringToHexArray,
        hexToByte,
        Bytes2HexString,
        hexArrayToString,
        getVersionVal,
        compareAndUpgrade,
        generateSignature,
        hexStringToHexArray,
        toByteArray,
        getDicts,
        combineBytesToDecimal
    }
}